﻿
namespace Biciq.Web.UI.Servicios
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;
    using Biciq.Datos;
    using Biciq.Logica;
    using System.Text;
    using System.Configuration;
    using System.IO;


    // Implements application logic using the BiciqContexto context.
    // TODO: Add your application logic to these methods or in additional methods.
    // TODO: Wire up authentication (Windows/ASP.NET Forms) and uncomment the following to disable anonymous access
    // Also consider adding roles to restrict access as appropriate.
    // [RequiresAuthentication]
    [EnableClientAccess()]
    public class BiciqDomainService : LinqToEntitiesDomainService<BiciqContexto>
    {

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Accesoes' query.
        public IQueryable<Acceso> GetAccesoes()
        {
            return this.ObjectContext.Accesoes;
        }

        public void InsertAcceso(Acceso acceso)
        {
            if ((acceso.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(acceso, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Accesoes.AddObject(acceso);
            }
        }

        public void UpdateAcceso(Acceso currentAcceso)
        {
            this.ObjectContext.Accesoes.AttachAsModified(currentAcceso, this.ChangeSet.GetOriginal(currentAcceso));
        }

        public void DeleteAcceso(Acceso acceso)
        {
            if ((acceso.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(acceso, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Accesoes.Attach(acceso);
                this.ObjectContext.Accesoes.DeleteObject(acceso);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Agencias' query.
        public IQueryable<Agencia> GetAgencias()
        {
            return this.ObjectContext.Agencias;
        }

        public void InsertAgencia(Agencia agencia)
        {
            if ((agencia.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(agencia, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Agencias.AddObject(agencia);
            }
        }

        public void UpdateAgencia(Agencia currentAgencia)
        {
            this.ObjectContext.Agencias.AttachAsModified(currentAgencia, this.ChangeSet.GetOriginal(currentAgencia));
        }

        public void DeleteAgencia(Agencia agencia)
        {
            if ((agencia.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(agencia, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Agencias.Attach(agencia);
                this.ObjectContext.Agencias.DeleteObject(agencia);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Auditorias' query.
        public IQueryable<Auditoria> GetAuditorias()
        {
            return this.ObjectContext.Auditorias;
        }

        public void InsertAuditoria(Auditoria auditoria)
        {
            if ((auditoria.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(auditoria, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Auditorias.AddObject(auditoria);
            }
        }

        public void UpdateAuditoria(Auditoria currentAuditoria)
        {
            this.ObjectContext.Auditorias.AttachAsModified(currentAuditoria, this.ChangeSet.GetOriginal(currentAuditoria));
        }

        public void DeleteAuditoria(Auditoria auditoria)
        {
            if ((auditoria.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(auditoria, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Auditorias.Attach(auditoria);
                this.ObjectContext.Auditorias.DeleteObject(auditoria);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Cargoes' query.
        public IQueryable<Cargo> GetCargoes()
        {
            return this.ObjectContext.Cargoes;
        }

        public void InsertCargo(Cargo cargo)
        {
            if ((cargo.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cargo, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Cargoes.AddObject(cargo);
            }
        }

        public void UpdateCargo(Cargo currentCargo)
        {
            this.ObjectContext.Cargoes.AttachAsModified(currentCargo, this.ChangeSet.GetOriginal(currentCargo));
        }

        public void DeleteCargo(Cargo cargo)
        {
            if ((cargo.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cargo, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Cargoes.Attach(cargo);
                this.ObjectContext.Cargoes.DeleteObject(cargo);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Clientes' query.
        public IQueryable<Cliente> GetClientes()
        {
            return this.ObjectContext.Clientes;
        }

        public void InsertCliente(Cliente cliente)
        {
            if ((cliente.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cliente, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Clientes.AddObject(cliente);
            }
        }

        public void UpdateCliente(Cliente currentCliente)
        {
            this.ObjectContext.Clientes.AttachAsModified(currentCliente, this.ChangeSet.GetOriginal(currentCliente));
        }

        public void DeleteCliente(Cliente cliente)
        {
            if ((cliente.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cliente, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Clientes.Attach(cliente);
                this.ObjectContext.Clientes.DeleteObject(cliente);
            }
        }

      

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Empleadoes' query.
        public IQueryable<Empleado> GetEmpleadoes()
        {
            
            return this.ObjectContext
                .Empleadoes
                .Include("Usuario")
                 .Include("Usuario.Rol")
                 .Include("Tarjeta")
                .Where(e => e.estado == "ACT");

        }


   

        public void InsertEmpleado(Empleado empleado)
        {
            empleado.Usuario.clave = Comun.encript(empleado.Usuario.clave);
            if ((empleado.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(empleado, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Empleadoes.AddObject(empleado);
            }
        }

        public void UpdateEmpleado(Empleado currentEmpleado)
        {
            this.ObjectContext.Empleadoes.AttachAsModified(currentEmpleado, this.ChangeSet.GetOriginal(currentEmpleado));
        }

        public void DeleteEmpleado(Empleado empleado)
        {
            if ((empleado.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(empleado, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Empleadoes.Attach(empleado);
                this.ObjectContext.Empleadoes.DeleteObject(empleado);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Pais' query.
        public IQueryable<Pai> GetPais()
        {
            return this.ObjectContext.Pais.OrderBy(p=>p.Nombre);
        }

        public void InsertPai(Pai pai)
        {
            if ((pai.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(pai, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Pais.AddObject(pai);
            }
        }

        public void UpdatePai(Pai currentPai)
        {
            this.ObjectContext.Pais.AttachAsModified(currentPai, this.ChangeSet.GetOriginal(currentPai));
        }

        public void DeletePai(Pai pai)
        {
            if ((pai.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(pai, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Pais.Attach(pai);
                this.ObjectContext.Pais.DeleteObject(pai);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Parametroes' query.
        public IQueryable<Parametro> GetParametroes()
        {
            return this.ObjectContext.Parametroes;
        }

        public void InsertParametro(Parametro parametro)
        {
            if ((parametro.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(parametro, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Parametroes.AddObject(parametro);
            }
        }

        public void UpdateParametro(Parametro currentParametro)
        {
            this.ObjectContext.Parametroes.AttachAsModified(currentParametro, this.ChangeSet.GetOriginal(currentParametro));
        }

        public void DeleteParametro(Parametro parametro)
        {
            if ((parametro.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(parametro, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Parametroes.Attach(parametro);
                this.ObjectContext.Parametroes.DeleteObject(parametro);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Recursoes' query.
        public IQueryable<Recurso> GetRecursoes()
        {
            return this.ObjectContext.Recursoes;
        }

        public void InsertRecurso(Recurso recurso)
        {
            if ((recurso.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(recurso, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Recursoes.AddObject(recurso);
            }
        }

        public void UpdateRecurso(Recurso currentRecurso)
        {
            this.ObjectContext.Recursoes.AttachAsModified(currentRecurso, this.ChangeSet.GetOriginal(currentRecurso));
        }

        public void DeleteRecurso(Recurso recurso)
        {
            if ((recurso.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(recurso, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Recursoes.Attach(recurso);
                this.ObjectContext.Recursoes.DeleteObject(recurso);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Rols' query.
        public IQueryable<Rol> GetRols()
        {
            return this.ObjectContext.Rols.Where(r=>r.estado=="ACT");
        }

        public void InsertRol(Rol rol)
        {
            if ((rol.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(rol, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Rols.AddObject(rol);
            }
        }

        public void UpdateRol(Rol currentRol)
        {
            this.ObjectContext.Rols.AttachAsModified(currentRol, this.ChangeSet.GetOriginal(currentRol));
        }

        public void DeleteRol(Rol rol)
        {
            if ((rol.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(rol, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Rols.Attach(rol);
                this.ObjectContext.Rols.DeleteObject(rol);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Tarjetas' query.
        public IQueryable<Tarjeta> GetTarjetas()
        {
            return this.ObjectContext

                .Tarjetas
           ;
        }

        public void InsertTarjeta(Tarjeta tarjeta)
        {
            if ((tarjeta.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tarjeta, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Tarjetas.AddObject(tarjeta);
            }
        }

        public void UpdateTarjeta(Tarjeta currentTarjeta)
        {
            this.ObjectContext.Tarjetas.AttachAsModified(currentTarjeta, this.ChangeSet.GetOriginal(currentTarjeta));
        }

        public void DeleteTarjeta(Tarjeta tarjeta)
        {
            if ((tarjeta.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tarjeta, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Tarjetas.Attach(tarjeta);
                this.ObjectContext.Tarjetas.DeleteObject(tarjeta);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'TipoSuscripcions' query.
        public IQueryable<TipoSuscripcion> GetTipoSuscripcions()
        {
            return this.ObjectContext.TipoSuscripcions;
        }

        public void InsertTipoSuscripcion(TipoSuscripcion tipoSuscripcion)
        {
            if ((tipoSuscripcion.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tipoSuscripcion, EntityState.Added);
            }
            else
            {
                this.ObjectContext.TipoSuscripcions.AddObject(tipoSuscripcion);
            }
        }

        public void UpdateTipoSuscripcion(TipoSuscripcion currentTipoSuscripcion)
        {
            this.ObjectContext.TipoSuscripcions.AttachAsModified(currentTipoSuscripcion, this.ChangeSet.GetOriginal(currentTipoSuscripcion));
        }

        public void DeleteTipoSuscripcion(TipoSuscripcion tipoSuscripcion)
        {
            if ((tipoSuscripcion.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tipoSuscripcion, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.TipoSuscripcions.Attach(tipoSuscripcion);
                this.ObjectContext.TipoSuscripcions.DeleteObject(tipoSuscripcion);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Usuarios' query.
        public IQueryable<Usuario> GetUsuarios()
        {
            return this.ObjectContext.Usuarios.Where(u=>u.estado=="ACT");
        }

        public void InsertUsuario(Usuario usuario)
        {
            if ((usuario.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(usuario, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Usuarios.AddObject(usuario);
            }
        }

        public void UpdateUsuario(Usuario currentUsuario)
        {
            this.ObjectContext.Usuarios.AttachAsModified(currentUsuario, this.ChangeSet.GetOriginal(currentUsuario));
        }

        public void DeleteUsuario(Usuario usuario)
        {
            if ((usuario.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(usuario, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Usuarios.Attach(usuario);
                this.ObjectContext.Usuarios.DeleteObject(usuario);
            }
        }

        public IQueryable<Cliente> FullTextSearchCliente(string busqueda, string estado)
        {
            var clientes = this.ObjectContext.ExecuteStoreQuery<Cliente>("SELECT * FROM Cliente as e WHERE FREETEXT(e.*, {0}) and Estado = {1}", busqueda,estado)
            .AsQueryable();
            return clientes;
        }

        public IQueryable<Cliente> BuscarClientesPorEstado( string estado)
        {

            var Clientes = this.ObjectContext.Clientes
                .Include("Pai")
                .Include("Tarjeta")
                .Where(c => c.Estado == estado).OrderBy(c => c.Apellidos);//.Skip(1 * 10).Take(10);

            

            
            return Clientes;
        }

         [Invoke]
        public List<String> ObtenerNumeroUsuarios()
        {
            List<string> mensajes = new List<string>();
            var numeroActivos = this.ObjectContext.Clientes.Where(c => c.Estado == "Activo").Count();
            var numeroRechazados = this.ObjectContext.Clientes.Where(c => c.Estado == "Rechazado").Count();
            var numeroRegitrados = this.ObjectContext.Clientes.Where(c => c.Estado == "Registrado").Count();
            var numeroAprobados = this.ObjectContext.Clientes.Where(c => c.Estado == "PendientePago").Count();
            var numeroCaducados = this.ObjectContext.Clientes.Where(c => c.Estado == "Caducado").Count();


            var mensajeRegistrados = "Usuarios Registrados: " + numeroRegitrados.ToString();
            var mensajeActivos = "Usuarios Activos: " + numeroActivos.ToString();
            var mensajeRechazados = "Usuarios Rechazados: " + numeroRechazados.ToString();
            var mensajeAprobados = "Usuarios Aprobados: " + numeroAprobados.ToString();
            var mensajeCaducados = "Usuarios Caducados: " + numeroCaducados.ToString();

            mensajes.Add(mensajeRegistrados);
            mensajes.Add(mensajeActivos);
            mensajes.Add(mensajeRechazados);

            mensajes.Add(mensajeAprobados); 
             mensajes.Add(mensajeCaducados);
            return mensajes;


        }
         [Invoke]
         public string ObtenerValorSuscripcion(Guid tipoSuscripcion)
         {

             RegistroNegocio negocio = new RegistroNegocio();


             return negocio.ObtenerValorSuscripcion(tipoSuscripcion);
         }

         [Invoke]
         public decimal ObtenerValorSuscripcionPorTipo(Guid tipoSuscripcion)
         {

             RegistroNegocio negocio = new RegistroNegocio();


             return negocio.ObtenerValorSuscripcionPorTipo(tipoSuscripcion);
         }

         public IQueryable<Rechazo> GetRechazoes()
         {
             return this.ObjectContext.Rechazoes;
         }

         public void InsertAcceso(Rechazo rechazo)
         {
             if ((rechazo.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(rechazo, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.Rechazoes.AddObject(rechazo);
             }
         }

         public void UpdateRechazo(Rechazo currentRechazo)
         {
             this.ObjectContext.Rechazoes.AttachAsModified(currentRechazo, this.ChangeSet.GetOriginal(currentRechazo));
         }

         public void DeleteRechazo(Rechazo rechazo)
         {
             if ((rechazo.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(rechazo, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.Rechazoes.Attach(rechazo);
                 this.ObjectContext.Rechazoes.DeleteObject(rechazo);
             }
         }
         public IQueryable<Factura> GetFacturas()
         {
             return this.ObjectContext.Facturas;
         }

         public void InsertFactura(Factura factura)
         {
             if ((factura.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(factura, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.Facturas.AddObject(factura);
             }
         }

         public void UpdateFactura(Factura currentFactura)
         {
             this.ObjectContext.Facturas.AttachAsModified(currentFactura, this.ChangeSet.GetOriginal(currentFactura));
         }

         public void DeleteFactura(Factura factura)
         {
             if ((factura.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(factura, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.Facturas.Attach(factura);
                 this.ObjectContext.Facturas.DeleteObject(factura);
             }
         }

         public IQueryable<DetalleFactura> GetDetalleFacturas()
         {
             return this.ObjectContext.DetalleFacturas;
         }

         public void InsertDetalleFactura(DetalleFactura detalleFactura)
         {
             if ((detalleFactura.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(detalleFactura, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.DetalleFacturas.AddObject(detalleFactura);
             }
         }

         public void UpdateDetalleFactura(DetalleFactura currentDetalleFactura)
         {
             this.ObjectContext.DetalleFacturas.AttachAsModified(currentDetalleFactura, this.ChangeSet.GetOriginal(currentDetalleFactura));
         }

         public void DeleteDetalleFactura(DetalleFactura detalleFactura)
         {
             if ((detalleFactura.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(detalleFactura, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.DetalleFacturas.Attach(detalleFactura);
                 this.ObjectContext.DetalleFacturas.DeleteObject(detalleFactura);
             }
         }

         public IQueryable<FormaPago> GetFormaPago()
         {
             return this.ObjectContext.FormaPagoes;
         }

         public void InsertFormaPago(FormaPago formaPago)
         {
             if ((formaPago.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(formaPago, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.FormaPagoes.AddObject(formaPago);
             }
         }

         public void UpdateFormaPago(FormaPago currentFormaPago)
         {
             this.ObjectContext.FormaPagoes.AttachAsModified(currentFormaPago, this.ChangeSet.GetOriginal(currentFormaPago));
         }

         public void DeleteFormaPago(FormaPago formaPago)
         {
             if ((formaPago.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(formaPago, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.FormaPagoes.Attach(formaPago);
                 this.ObjectContext.FormaPagoes.DeleteObject(formaPago);
             }
         }

         public IQueryable<Rol> GetBusquedaRolNombre(string busqueda)
         {
             return this.ObjectContext.Rols.Where(r => r.estado == "ACT" && r.nombre.Contains(busqueda));
         }


         public IQueryable<Rol> GetRolNombre(string nombre)
         {
             return this.ObjectContext.Rols.Where(r => r.estado == "ACT" && r.nombre.ToUpper()==nombre.ToUpper());
         }
        

         public Result GetRolPorUsuario(Guid id)
         {
             Result result = new Result();
             result.estado = true;
             var usuariosRol = this.ObjectContext.Rols.Where(r => r.id == id).Select(r => r.Usuarios.Count()).FirstOrDefault();
             if (usuariosRol > 0)
             {
                 result.estado = false;
                 
             }

             return result;
         }

         public IQueryable<Rol> GetRolId(Guid  id)
         {
             return this.ObjectContext.Rols.Where(r => r.id == id);
         }

         public IQueryable<Recurso> GetRolRecursoId(Guid idRol)
         {
             
              var listaAccesos = this.ObjectContext.Accesoes
                  .Include("Recurso")
                  .Where(r => r.idRol == idRol);
              List<Recurso> recursos = new List<Recurso>();
              foreach (var item in listaAccesos)
              {
                  recursos.Add(item.Recurso);           
              }
              return recursos.AsQueryable();
         }

         public Result AgregarRolRecurso(List<string> lista, Guid idRol)
         {
             Result result = new Result();
             result.estado = true;
             result.mensaje = "Ok";
             try
             {
                 foreach (var item in this.ObjectContext.Accesoes.Where(a => a.idRol == idRol))
                 {
                     this.ObjectContext.DeleteObject(item);
                 }
                 foreach (var item in lista)
                 {
                     Acceso acceso = new Acceso();
                     acceso.estado = "ACT";
                     acceso.idRecurso = item;
                     acceso.idRol = idRol;
                     this.ObjectContext.Accesoes.AddObject(acceso);

                 }
                 this.ObjectContext.SaveChanges();
             }
             catch (Exception)
             {
                 
                  result.estado = true;
                    result.mensaje = "Ha ocurrido un error al agregar Accesos al Rol seleccionado, consulte con su Administrador de Sistema";
             }
             return result;
         }
         public IQueryable<Usuario> GetBusquedaUsuarioNombre(string busqueda)
         {
             return this.ObjectContext.Usuarios.Where(r => r.estado == "ACT" && r.nombreUsuario.Contains(busqueda));

         }
         public IQueryable<Usuario> GetUsuarioId(Guid id)
         {
             return this.ObjectContext.Usuarios.Where(r => r.id == id);
         }

         public IQueryable<Usuario> GetUsuarioNombre(string nombre)
         {
             return this.ObjectContext.Usuarios.Where(r =>  r.nombreUsuario.ToUpper() == nombre.ToUpper());
         }

         public IQueryable<Empleado> GetBusquedaEmpleadoNombre(string busqueda)
         {
             return this.ObjectContext
                 .Empleadoes
                 .Include("Tarjeta")
                 .Where(r => r.estado == "ACT" && r.nombresApellidos.Contains(busqueda));
         }
        
         public IQueryable<Empleado> GetEmpleadoId(Guid id)
         {
             return this.ObjectContext.Empleadoes.Where(r => r.id == id);
         }

       

         public Tarjeta  GetTarjetaPorCodigo(string codigo)
         {
             Result resultado = new Result();
             var tarjeta = this.ObjectContext.Tarjetas.Where(t=>t.codigo==codigo  && t.Estado=="DISPONIBLE").FirstOrDefault();
            

             return tarjeta;

             
         }


         public IQueryable<ClienteTarjeta > GetClienteTarjetas()
         {

             return this.ObjectContext
                 .ClienteTarjetas;
                

         }




         public void InsertClienteTarjeta(ClienteTarjeta clienteTarjeta)
         {

             if ((clienteTarjeta.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(clienteTarjeta, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.ClienteTarjetas.AddObject(clienteTarjeta);
             }
         }

         public void UpdateClienteTarjeta(ClienteTarjeta currentClienteTarjeta)
         {
             this.ObjectContext.ClienteTarjetas.AttachAsModified(currentClienteTarjeta, this.ChangeSet.GetOriginal(currentClienteTarjeta));
         }

         public void DeleteClienteTarjeta(ClienteTarjeta clienteTarjeta)
         {
             if ((clienteTarjeta.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(clienteTarjeta, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.ClienteTarjetas.Attach(clienteTarjeta);
                 this.ObjectContext.ClienteTarjetas.DeleteObject(clienteTarjeta);
             }
         }


         public IQueryable<Tarjeta> GetBusquedaTarjetaCodigo(string codigo)
         {
         
             return this.ObjectContext
                 
                 .Tarjetas
                 .Include("Clientes")
                 .Include("Empleadoes")
                   .Include("Estacions")
                 .Where(t => t.codigo == codigo);

         }


       public IQueryable<Estacion > GetEstacions()
         {

             return this.ObjectContext
                 .Estacions
                 .Where(e => e.Estado == "ACT");
                

         }

       public IQueryable<Estacion> GetEstacionDistancia()
       {

           return this.ObjectContext
               .Estacions
               .Include("Distancias")
               .Include("Distancias1")
               .Include("Distancias1.Estacion")
               .Where(e => e.Estado == "ACT")
               .OrderBy(e => e.Nombre);
       }


         public void InsertEstacion(Estacion estacion)
         {

             if ((estacion.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(estacion, EntityState.Added);
             }
             else
             {
                 this.ObjectContext.Estacions.AddObject(estacion);
             }
         }

         public void UpdateEstacion(Estacion currentEstacion)
         {
             this.ObjectContext.Estacions.AttachAsModified(currentEstacion, this.ChangeSet.GetOriginal(currentEstacion));
         }

         public void DeleteEstacion(Estacion estacion)
         {
             if ((estacion.EntityState != EntityState.Detached))
             {
                 this.ObjectContext.ObjectStateManager.ChangeObjectState(estacion, EntityState.Deleted);
             }
             else
             {
                 this.ObjectContext.Estacions.Attach(estacion);
                 this.ObjectContext.Estacions.DeleteObject(estacion);
             }
         }

          public IQueryable<Estacion> GetEstacionNombre(string nombre)
         {
             return this.ObjectContext.Estacions.Where(r => r.Nombre.ToUpper() == nombre.ToUpper());
         }
        
          public IQueryable<Estacion> GetBusquedaEstacionNombre(string busqueda)
         {
             return this.ObjectContext
                 .Estacions
                 .Include("Tarjeta")
                 .Where(r => r.Estado == "ACT" && r.Nombre.Contains(busqueda));
         }

          public IQueryable<Estacion> GetEstacionId(Guid id)
          {
              return this.ObjectContext.Estacions.Where(r => r.Id == id);
          }


          public IQueryable<Bicicleta> GetBicicletas()
          {
              return this.ObjectContext.Bicicletas;
          }

          public void InsertBicileta(Bicicleta bicileta)
          {
              if ((bicileta.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(bicileta, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.Bicicletas.AddObject(bicileta);
              }
          }

          public void UpdateBicileta(Bicicleta currentBicleta)
          {
              this.ObjectContext.Bicicletas.AttachAsModified(currentBicleta, this.ChangeSet.GetOriginal(currentBicleta));
          }

          public void DeleteBicileta(Bicicleta bicicleta)
          {
              if ((bicicleta.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(bicicleta, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.Bicicletas.Attach(bicicleta);
                  this.ObjectContext.Bicicletas.DeleteObject(bicicleta);
              }
          }

          public IQueryable<Bicicleta> GetBicicletaId(Guid id)
          {
              return this.ObjectContext.Bicicletas.Where(r => r.Id == id);
          }

          public IQueryable<Bicicleta> GetBiciletaNombre(string chasis)
          {
              return this.ObjectContext.Bicicletas.Where(r => r.NumeroChasis.ToUpper() == chasis.ToUpper());
          }


          public IQueryable<Bicicleta> GetBusquedaBicicletaNombre(string busqueda)
         {
             return this.ObjectContext
                 .Bicicletas
                 .Include("Tarjeta")
                 .Where(r => r.Estado == "ACT" && r.NumeroChasis.Contains(busqueda));
         }




          public IQueryable<ParametrosSancione> GetParametrosSanciones()
          {
              return this.ObjectContext.ParametrosSanciones;
          }

          public void InsertParamtroSancione(ParametrosSancione paramtroSancione)
          {
              if ((paramtroSancione.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(paramtroSancione, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.ParametrosSanciones.AddObject(paramtroSancione);
              }
          }

          public void UpdateParamtroSancione(ParametrosSancione current)
          {
              this.ObjectContext.ParametrosSanciones.AttachAsModified(current, this.ChangeSet.GetOriginal(current));
          }

          public void DeleteParamtroSancione(ParametrosSancione parametro)
          {
              if ((parametro.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(parametro, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.ParametrosSanciones.Attach(parametro);
                  this.ObjectContext.ParametrosSanciones.DeleteObject(parametro);
              }
          }


          public IQueryable<Distancia> GetDistancias()
          {
              return this.ObjectContext.Distancias;
          }

          public void InsertDistancia(Distancia distancia)
          {
              if ((distancia.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(distancia, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.Distancias.AddObject(distancia);
              }
          }

          public void UpdateDistancia(Distancia currentDistancia)
          {
              this.ObjectContext.Distancias.AttachAsModified(currentDistancia, this.ChangeSet.GetOriginal(currentDistancia));
          }

          public void DeleteDistancia(Distancia distancia)
          {
              if ((distancia.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(distancia, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.Distancias.Attach(distancia);
                  this.ObjectContext.Distancias.DeleteObject(distancia);
              }
          }



          public IQueryable<AperturaCaja> GetAperturaCaja()
          {
              return this.ObjectContext.AperturaCajas;
          }
          public IQueryable<AperturaCaja> GetAperturaCajaFecha()
          {
              return this.ObjectContext.AperturaCajas.Where(a => a.FechaAperturaCaja.Day == DateTime.Now.Day && a.FechaAperturaCaja.Month == DateTime.Now.Month && a.FechaAperturaCaja.Year == DateTime.Now.Year);

          }
          public void InsertAperturaCaja(AperturaCaja aperturaCaja)
          {
              if ((aperturaCaja.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(aperturaCaja, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.AperturaCajas.AddObject(aperturaCaja);
              }
          }

          public void UpdateAperturaCaja(AperturaCaja aperturaCaja)
          {
              this.ObjectContext.AperturaCajas.AttachAsModified(aperturaCaja, this.ChangeSet.GetOriginal(aperturaCaja));
          }

          public void DeleteAperturaCaja(AperturaCaja aperturaCaja)
          {
              if ((aperturaCaja.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(aperturaCaja, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.AperturaCajas.Attach(aperturaCaja);
                  this.ObjectContext.AperturaCajas.DeleteObject(aperturaCaja);
              }
          }


          public IQueryable<CierreCaja> GetCierreCaja()
          {
              return this.ObjectContext.CierreCajas;
          }

          public void InsertCierreCaja(CierreCaja CierreCaja)
          {
              if ((CierreCaja.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(CierreCaja, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.CierreCajas.AddObject(CierreCaja);
              }
          }

          public void UpdateCierreCaja(CierreCaja CierreCaja)
          {
              this.ObjectContext.CierreCajas.AttachAsModified(CierreCaja, this.ChangeSet.GetOriginal(CierreCaja));
          }

          public void DeleteCierreCaja(CierreCaja CierreCaja)
          {
              if ((CierreCaja.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(CierreCaja, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.CierreCajas.Attach(CierreCaja);
                  this.ObjectContext.CierreCajas.DeleteObject(CierreCaja);
              }
          }

          public AperturaCaja AperturaCajaDia()
          {
              AperturaCaja aperturaDia = null;
              using (BiciqContexto contexto = new BiciqContexto())
              {
                  aperturaDia = contexto.AperturaCajas.Where(a =>
                      a.FechaAperturaCaja.Day == DateTime.Now.Day &&
                      a.FechaAperturaCaja.Month == DateTime.Now.Month &&
                      a.FechaAperturaCaja.Year == DateTime.Now.Year).FirstOrDefault();


              }
              return aperturaDia;

          }

          public CierreCaja CierreCajaDia()
          {
              CierreCaja cierreDia = null;
              using (BiciqContexto contexto = new BiciqContexto())
              {
                  cierreDia = contexto.CierreCajas.Where(a =>
                      a.FechaCierreCaja.Day == DateTime.Now.Day &&
                      a.FechaCierreCaja.Month == DateTime.Now.Month &&
                      a.FechaCierreCaja.Year == DateTime.Now.Year).FirstOrDefault();


              }
              return cierreDia;

          }
          public decimal CierreCajaEsperado()
          {
              decimal valorEsperado = 0;
              using (BiciqContexto contexto = new BiciqContexto())
              {
                  var aperturaCajaDia = AperturaCajaDia();
                  if ( aperturaCajaDia!= null)
                  {
                      valorEsperado = valorEsperado + aperturaCajaDia.ValorAperturaCaja;

                  }

                  var facturacionDia = contexto.Facturas.Where(a =>
                      a.Fecha.Value.Day == DateTime.Now.Day &&
                      a.Fecha.Value.Month == DateTime.Now.Month &&
                      a.Fecha.Value.Year == DateTime.Now.Year
                      && a.Facturado.Value
                      );

                  if (facturacionDia.Count()>0)
                  {
                      valorEsperado = valorEsperado + facturacionDia.Sum(f=>f.Total).Value;
                  }

              

              }
              return valorEsperado;
          }

          public Tarjeta GetTarjetaPorId(Guid idTarjeta)
          {
              Tarjeta tarjeta = null;
              using (BiciqContexto contexto = new BiciqContexto())
              {
                  tarjeta = contexto.Tarjetas.Where(t=>t.id==idTarjeta).FirstOrDefault();
              }
              return tarjeta;
          }


          public IQueryable<Estacion> ConsultarEstaciones()
          {
              
              return this.ObjectContext.Estacions
                  .Include("EstacionBiciletas")
                  .Include("EstacionBiciletas.Bicicleta")
                  .Where(e => e.Estado == "ACT");

          }

          public IQueryable<EstacionBicileta> ConsultarEstacionesBicileta()
          {
              return this.ObjectContext.EstacionBiciletas;

          }

          public IQueryable<BajaBloqueoInscripcion> GetBajaBloqueoInscripcions()
          {
              return this.ObjectContext.BajaBloqueoInscripcions;
          }

          public void InsertBajaBloqueoInscripcion(BajaBloqueoInscripcion bajaBloqueoInscripcion)
          {
              bajaBloqueoInscripcion.fechaBaja = DateTime.Now;
              if ((bajaBloqueoInscripcion.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(bajaBloqueoInscripcion, EntityState.Added);
              }
              else
              {
                  this.ObjectContext.BajaBloqueoInscripcions.AddObject(bajaBloqueoInscripcion);
              }
          }

          public void UpdateBajaBloqueoInscripcion(BajaBloqueoInscripcion bajaBloqueoInscripcion)
          {
              this.ObjectContext.BajaBloqueoInscripcions.AttachAsModified(bajaBloqueoInscripcion, this.ChangeSet.GetOriginal(bajaBloqueoInscripcion));
          }

          public void DeleteBajaBloqueoInscripcion(BajaBloqueoInscripcion bajaBloqueoInscripcion)
          {
              if ((bajaBloqueoInscripcion.EntityState != EntityState.Detached))
              {
                  this.ObjectContext.ObjectStateManager.ChangeObjectState(bajaBloqueoInscripcion, EntityState.Deleted);
              }
              else
              {
                  this.ObjectContext.BajaBloqueoInscripcions.Attach(bajaBloqueoInscripcion);
                  this.ObjectContext.BajaBloqueoInscripcions.DeleteObject(bajaBloqueoInscripcion);
              }
          }

          #region Seguimiento por Bicileta

          public List<Bicicleta> ConsultarBicicletasConRetardo()
          {
                      //var bicicletas = from bicicletas in ObjectContext.Bicicletas
                      //                 join detalles in ObjectContext.DetalleOperacions on bicicletas.Id equals detalles.IdBicicleta 
                      //                 join operacion in ObjectContext.Operacions on detalles.IdOperacion equals operacion.Id
                      //                 where operacion.IdTipoOperacion.Value equals '1C6F54A2-AB24-45AA-BD1C-55E06F26F05E'
                                       



                
             

              return new List<Bicicleta>();
          }

          public IQueryable<VistaBicicleta> ConsultarBicicletaPorNumero()
          {

              #region Codigo Anterior
              //var bicicletas = this.ObjectContext.Bicicletas
              //    .Include("EstacionBiciletas")
              //     .Include("EstacionBiciletas.Estacion")
              //    .Include("ClienteBicicletas")
              //    .Include("ClienteBicicletas.Cliente")
                
              //    ;


             
          
              //foreach (var item in bicicletas)
              //{
              //    if (item.ClienteBicicletas.Count > 0)
              //    {
              //        item.ColorAviso = "Black";
              //        var cliente = item.ClienteBicicletas.FirstOrDefault().Cliente;

              //        StringBuilder builder = new StringBuilder();
              //        builder.Append("Bicileta ");
              //        builder.Append(item.Numero);
              //        builder.Append(" prestada: ");
              //        builder.Append(cliente.NombresApellidos);
              //        builder.AppendLine();
              //        builder.Append("Identificación: ");
              //        builder.Append(cliente.Identificacion);
              //        builder.AppendLine();
              //        builder.Append("Teléfono: ");
              //        builder.Append(cliente.Telefono);
              //        builder.AppendLine();
              //        builder.Append("Celular: ");
              //        builder.Append(cliente.Mobil == null? "" : cliente.Mobil);

              //        var historiaBicileta = this.ObjectContext.HistoriaClientes.Where(h=>h.IdCliente == cliente.Id && h.MinutosRecorrido==null).OrderByDescending(h=>h.Fecha).FirstOrDefault();
              //        if (historiaBicileta!=null)
              //        {

              //            builder.AppendLine();
              //            builder.Append("Fecha Préstamo: ");
              //            builder.Append(historiaBicileta.Fecha.Value.ToString("dd/MM/yyyy"));

              //              builder.AppendLine();
              //              builder.Append("Hora Préstamo: ");
              //              builder.Append(historiaBicileta.HoraPrestamo.ToString());


              //              if (DateTime.Now.Subtract(historiaBicileta.Fecha.Value).TotalMinutes > 35 && DateTime.Now.Subtract(historiaBicileta.Fecha.Value).TotalMinutes<45)
              //              {
              //                  item.ColorAviso = "Orange";
              //                  Comun.enviarCorreo(new AppSettingsReader().GetValue("MailCoordinacion", item.ColorAviso.GetType()).ToString(), "Bicileta con tiempo de uso excedido", "Bicicleta " + item.Numero + "ha pasado el límite permitido de uso. Cliente asignado: " + cliente.NombresApellidos + " ,  identificación: " + cliente.Identificacion + " telefono: " + cliente.Telefono + " , celular: " + cliente.Mobil);
              //              }

              //              if (DateTime.Now.Subtract(historiaBicileta.Fecha.Value).TotalMinutes >= 45)
              //              {
              //                  item.ColorAviso = "Red";
              //                  Comun.enviarCorreo(new AppSettingsReader().GetValue("MailCoordinacion", item.ColorAviso.GetType()).ToString(), "Bicileta con tiempo de uso excedido", "Bicicleta " + item.Numero + "ha pasado el límite permitido de uso. Cliente asignado: " + cliente.NombresApellidos + " ,  identificación: " + cliente.Identificacion + " telefono: " + cliente.Telefono + " , celular: " + cliente.Mobil);
              //              }

                            
              //                  item.ToolTip = builder.ToString();
              //            }
              //    }
              //    else
              //    {
                      
              //        if (item.EstacionBiciletas.FirstOrDefault()!= null)
              //        {
              //            item.ColorAviso = "Blue";
              //            item.ToolTip = "Bicicleta " + item.Numero + " en estación: " + item.EstacionBiciletas.FirstOrDefault().Estacion.Nombre;
              //        }
              //        else
              //        {
              //            item.ColorAviso = "Black";
              //            item.ToolTip = "Bicicleta " + item.Numero + " no se encuentra en  estación ni prestada.";
              //        }
              //    }
              //}

              //return bicicletas;
              
              
              #endregion

              return this.ObjectContext.VistaBicicletas;

          }


        #endregion

          #region Bakup BDD

          public Result BakupBDD()
          {
              Result resultado = new Result();
              resultado.estado = true;
              resultado.mensaje = "Ok";


              try
              {
                  StringBuilder query = new StringBuilder();
                  //query.AppendLine("USE [(Biciq.Datos)];");
                  //query.AppendLine("GO");
                  query.AppendLine("BACKUP DATABASE [(Biciq.Datos)]");
                  query.Replace("(Biciq.Datos)", "Biciq.Datos");
                  query.AppendLine("TO DISK = '[CarpetaBackups]'");
                  var nombreBackup = "Backup" + DateTime.Now.ToString("ddMMyyyyhhmmss") +".bak";
                  query.Replace("[CarpetaBackups]", new AppSettingsReader().GetValue("CarpetaBackups", resultado.mensaje.GetType()).ToString() + nombreBackup);
                  query.AppendLine(" WITH FORMAT,");
                  query.AppendLine("MEDIANAME = 'Z_SQLServerBackups',");
                  query.AppendLine("NAME = 'Full Backup of Biciq.Datos'");
                  //query.AppendLine("GO");


                  this.ObjectContext.ExecuteStoreCommand(query.ToString());
                  resultado.mensaje = "El Respaldo " + nombreBackup + " se ha generado satisfactoriamente";
              }
              catch (Exception ex)
              {

                  resultado.estado = false;
                  resultado.mensaje = "Error al realizar Respaldo de Base de Datos " + ex.Message;
              }


              return resultado;
          }

    [Invoke]
          public List<ArchivoBackup> LeerArchivosBackup()
          {

              List<ArchivoBackup> backups = new List<ArchivoBackup>();
              string tipo = "";

              DirectoryInfo oDirectorio = new DirectoryInfo(new AppSettingsReader().GetValue("CarpetaBackups", tipo.GetType()).ToString());
              foreach (FileInfo file in oDirectorio.GetFiles())
              {
                  ArchivoBackup archivo = new ArchivoBackup();
                  archivo.extension = file.Extension;
                  archivo.fecha = file.LastWriteTime;
                  archivo.nombre = file.Name;
                  archivo.directorio = file.DirectoryName;

                  backups.Add(archivo);
                  
              }

              return backups;
              
          }
        #endregion

        #region Seguimiento Cliente
        public IQueryable<VistaHistoriaCliente> ConsultarHistoriaCliente(Guid idCliente)
        {
            return this.ObjectContext.VistaHistoriaClientes.Where(hc => hc.IdCliente == idCliente);
        }


        public IQueryable<VistaHistoriaBicicleta> ConsultarHistoriaBicicleta(Guid idBicileta)
        {
           var historia=  this.ObjectContext.VistaHistoriaBicicletas.Where(hc => hc.Id == idBicileta);
           return historia;
           
        }

       
        public IQueryable<VistaProceso> ConsultarEjecucionOperaciones()
        {
            var operaciones = this.ObjectContext.VistaProcesoes.OrderByDescending(p=>p.Fecha);
            return operaciones;
        }

        #endregion
    }

}


